




//#include <stdio.h>
//#include "mixsave.h"
//#include "list.h"
//#include "tls.h"
////#include "heap_4.h"
////#include "easyflash.h"

///* Mix save data struct:
//    /------------------------------------------/
//	|                                          |
//	|           listItem                       |
//	|                                          |
//	|------------------------------------------|
//	|                                          |
//	|        name buffer[x] + 1                |
//	|                                          |
//	|------------------------------------------|
//	|                                          |
//	|        4byte data block size             |
//	|                                          |
//	|------------------------------------------|
//	|                                          |
//	|        data buffer[x]                    |
//	|                                          |
//	\------------------------------------------\
//*/
///* Mix save list */
//List_t xMixSaveList;

///* list pointer */
//List_t* pxMixSaveList;

///* statistics */
//uint32 ulTotalMem = 0;

///*###########################################*/

///**
// * @fn      
// * @brief  
// * @param   
// * @return  */

///**
// * @fn      
// * @brief  
// * @param   
// * @return  */
//void vMxsInit(void)
//{
//	/* Create list */
//	vListInitialise(&xMixSaveList);

//	/* point for list */
//	pxMixSaveList = &xMixSaveList;

//	/* statistics total memory. */
//	ulTotalMem = 0;
//}

///**
// * @fn      
// * @brief  
// * @param   
// * @return  */
//char* prvNamePcGet(ListItem_t* pxItem)
//{
//	char* pcName;

//	pcName = pxItem->pvOwner;

//	//LOG("%s name:%s\r\n",__FUNCTION__ , pcName);
//	return pcName;
//}

///**
// * @fn      
// * @brief  
// * @param   
// * @return  */
//uint16 prvDataSizeGet(ListItem_t* pxItem)
//{
//	uint32 ulVal;
//	uint8* pcBuffer;

//	uint8 ucOfsName;

//	/* Start pointer is name pc; */
//	pcBuffer = pxItem->pvOwner;

//	/* name offset. */
//	LOG("\r\n");
//	LOG("%s name:%s\r\n",__FUNCTION__ , pcBuffer);
//	ucOfsName = tlsAlignSizeGet(strlen((char*)pcBuffer) + 1) ;

//	/* data size get. */
//	ulVal  = pcBuffer[ucOfsName + 0];
//	ulVal <<= 8;

//	ulVal += pcBuffer[ucOfsName + 1];
//	ulVal <<= 8;

//	ulVal += pcBuffer[ucOfsName + 2];
//	ulVal <<= 8;

//	ulVal += pcBuffer[ucOfsName + 3];
//	
//	/* data size return. */
//	LOG("\r\n");
//	LOG("%s data size:%d\r\n",__FUNCTION__ , ulVal);
//	return ulVal;
//}

///**
// * @fn      
// * @brief  
// * @param   
// * @return  */
//uint16 prvDataContentGet(ListItem_t* pxItem , uint8 *pcRead , uint16 usGetSize)
//{
//	uint8* pcBuffer;
//	uint8  ucOfsTotal = 0 ;
//	uint32 ulSize;

//	/* Start pointer is name pc; */
//	pcBuffer = pxItem->pvOwner;

//	/* name offset. */
//	//LOG("\r\n");
//	//LOG("%s name:%s\r\n",__FUNCTION__ , pcBuffer);
//	ucOfsTotal += tlsAlignSizeGet(strlen((char*)pcBuffer) + 1);

//	/* Get data size. */
//	ulSize  = pcBuffer[ucOfsTotal + 0];
//	ulSize <<= 8;

//	ulSize += pcBuffer[ucOfsTotal + 1];
//	ulSize <<= 8;

//	ulSize += pcBuffer[ucOfsTotal + 2];
//	ulSize <<= 8;

//	ulSize += pcBuffer[ucOfsTotal + 3];

//	/* data size offset */
//	ucOfsTotal += 4;

//	/* Copy data to buffer. */
//	//LOG("\r\n");
//	//LOG("%s data size:%d , get:%d\r\n",__FUNCTION__ , ulSize , usGetSize);
//	if (ulSize >= usGetSize){
//		memcpy(pcRead , &pcBuffer[ucOfsTotal] , usGetSize);
//		return usGetSize;
//	}
//	else {
//		memcpy(pcRead , &pcBuffer[ucOfsTotal] , ulSize);
//		return ulSize;
//	}
//}

///**
// * @fn      
// * @brief   
// * @param   
// * @return  */
//uint8* prvDataPcGet(ListItem_t* pxItem ,uint16 *usSize )
//{
//	uint8* pcBuffer;
//	uint8  ucOfsTotal = 0;
//	uint32 ulSize;

//	/* Start pointer is name pc; */
//	pcBuffer = pxItem->pvOwner;

//	/* name offset. */
//	LOG("\r\n");
//	LOG("%s name:%s\r\n", __FUNCTION__, pcBuffer);
//	ucOfsTotal += tlsAlignSizeGet(strlen((char*)pcBuffer) + 1);

//	/* Get data size. */
//	ulSize = pcBuffer[ucOfsTotal + 0];
//	ulSize <<= 8;

//	ulSize += pcBuffer[ucOfsTotal + 1];
//	ulSize <<= 8;

//	ulSize += pcBuffer[ucOfsTotal + 2];
//	ulSize <<= 8;

//	ulSize += pcBuffer[ucOfsTotal + 3];

//	/* data size offset */
//	ucOfsTotal += 4;

//	/* return pc. */
//	//pcRead = (uint8*)(&pcBuffer[ucOfsTotal]);
//	*usSize = ulSize;


//	/* reutrn size. */
//	return &pcBuffer[ucOfsTotal];
//}

///**
// * @fn      
// * @brief   
// * @param   
// * @return  */
//uint16 prvItemUseSpaceGet(ListItem_t* pxItem)
//{
//	uint32 ulSize = 0;
//	uint16 usTemp;

//	/* item size. */
//	ulSize += tlsAlignSizeGet(sizeof(ListItem_t));

//	/* strlen */
//	usTemp = strlen(prvNamePcGet(pxItem));
//	ulSize += tlsAlignSizeGet(usTemp+1);

//	/* data size + data  */
//	ulSize += 4;
//	ulSize += tlsAlignSizeGet(prvDataSizeGet(pxItem)) ;

//	LOG("\r\n");
//	LOG("%s size:%d\r\n",__FUNCTION__ , ulSize);
//	return ulSize;
//}

///**
// * @fn      
// * @brief   
// * @param   
// * @return null or item. */
//ListItem_t* pxFindItem(char *pcKey)
//{
//	uint16 usHashValue = tlsStringHashValueGet(pcKey);

//	/* Get number of items. */
//	uint16 usNbItem = pxMixSaveList->uxNumberOfItems;

//	/* Get first node. */
//	ListItem_t* pxListitem = listGET_HEAD_ENTRY(pxMixSaveList);

//	while (usNbItem) {
//		/* Hash value is equal. */
//		if (pxListitem->xItemValue == usHashValue) {

//			/* Compare with key value. */
//			if (strcmp(prvNamePcGet(pxListitem), pcKey) == 0) {
//				return pxListitem;
//			}
//		}

//		/* get next item */
//		pxListitem = pxListitem->pxNext;

//		/* continue ... */
//		usNbItem--;
//	}

//	return NULL;
//}

///**
// * @fn      
// * @brief   first Item.
//	|------------------------------------------|
//	|                                          |
//	|        name buffer[x] + 1                |
//	|                                          |
//	|------------------------------------------|
//	|                                          |
//	|        4byte data block size             |
//	|                                          |
//	|------------------------------------------|
//	|                                          |
//	|        data buffer[x]                    |
//	|                                          |
//	\------------------------------------------\
// * @param   
// * @return  */
//ListItem_t* pxFirstItem(void)
//{
//	/* Get number of items. */
//	uint16 usNbItem = pxMixSaveList->uxNumberOfItems;

//	/* ListItem */
//	ListItem_t* xItem;

//	/* Have item? */
//	if (usNbItem !=0){
//		
//		/* first item. */
//		xItem = listGET_HEAD_ENTRY(pxMixSaveList);

//		return xItem;
//	}else {
//		return NULL;
//	}
//}

///**
// * @fn      
// * @brief  Force insert a item.
// * @param   
// * @return  */
//MixSaveStatusDef mixWriteRamItem(char *pcKey , void *pcBuf , uint32 usSize)
//{
//	/* Calculation total input alignment size.
//	0	ListItem_t				x	bytes
//	2	pcName[0]				1	bytes
//	3	pcName[1]				1	bytes
//	4	pcName[2]				1	bytes
//	5	pcName[3]				1	bytes
//	6	pcName[...]				1	bytes
//	7	0						1	bytes
//		size(data block)				4	bytes
//	8	Data block[0]				1	bytes
//	9	Data block[1]				1	bytes
//	10	Data block[2]				1	bytes
//	11	Data block[3]				1	bytes
//	12	Data block[...]			*/
//	uint16 usTtlSize;
////	uint8  ucNameSize = strlen(pcKey) ;
//	
//	/* Offset. */
//	const uint8  ucOfsSize     = 4;
//		  uint8  ucOfsListItem = tlsAlignSizeGet(sizeof(ListItem_t)) ;
//		  uint8  ucOfsName     = tlsAlignSizeGet(strlen(pcKey) + 1) ;
//		  uint16 usOfsInr      = 0;

//	ListItem_t* pxListitem    = NULL;
//	uint8*      pcItemContent = NULL;

//	/* calculation total size. */
//	usTtlSize = ucOfsListItem +
//		ucOfsName + ucOfsSize + tlsAlignSizeGet(usSize);

//	/* Data block space. */
//	pcItemContent = osal_mem_alloc(usTtlSize);
//	
//	if (pcItemContent != NULL){

//		/* List node pointer. */
//		pxListitem = (ListItem_t*)pcItemContent;
//		
//		/* Hash value.easy to find. */
//		pxListitem->xItemValue = tlsStringHashValueGet(pcKey);

//		/* fill data.
//		   [hash + size]
//		   [string buffer +1 ]
//		   [data buffer]       */
//		/*>copy name string*/
//		usOfsInr = ucOfsListItem;
//		sprintf((char*)(&pcItemContent[usOfsInr]) , "%s" ,pcKey );
//		//memcpy(&pcItemContent[usOfsInr], pcKey, ucNameSize);
//		/* String end symbol. */
//		//pcItemContent[usOfsInr + ucNameSize + 1] = 0;

//		/*>byte 4 ,data size.*/
//		usOfsInr += ucOfsName;
//		pcItemContent[usOfsInr+0] = usSize>>24;
//		pcItemContent[usOfsInr+1] = usSize>>16;
//		pcItemContent[usOfsInr+2] = usSize>>8;
//		pcItemContent[usOfsInr+3] = usSize;
//		
//		/* fill data. */
//		usOfsInr += ucOfsSize;
//		memcpy(&pcItemContent[usOfsInr] , pcBuf , usSize);

//		/* Get data block. */
//		pxListitem->pvOwner = &pcItemContent[ucOfsListItem];

//		/* Inset list.(FIFO) */
//		vListInsert(pxMixSaveList , pxListitem);

//		/* memory statistics */
//		ulTotalMem += usTtlSize;

//		/* Print information. */
//		LOG("\r\n");
//		LOG("mix insert name:%s\r\n" , pcKey);
//		LOG("real size:%d\r\n"       , usTtlSize);
////		LOG("remain free:%d\r\n" , xPortGetFreeHeapSize());
////		LOG("mini free:%d\r\n"   , xPortGetMinimumEverFreeHeapSize());
//	}
//	else {
//		return eMXS_ERR_NESPACE;
//	}

//	return eMXS_ERR_NONE;
//}

///**
// * @fn      
// * @brief  Delete a item
// * @param   
// * @return  */
//MixSaveStatusDef mixDeleteRamItem(char *pcKey)
//{
//	/* Get first node. */
//	ListItem_t* pxListitem ;
//	uint16 usUseSpace;

//	pxListitem = pxFindItem(pcKey);

//	if (pxListitem != NULL){
//		
//		/* statistics memory. */
//		usUseSpace = prvItemUseSpaceGet(pxListitem);

//		if (ulTotalMem >= usUseSpace) {
//			ulTotalMem -= usUseSpace;
//		}else {
//			/* Usually not run here */
//			LOG("\r\n");
//			LOG("%s: error memory remian.\r\n", __FUNCTION__);
//		}

//		/* move item from list. */
//		uxListRemove(pxListitem);

//		/* delete this item. */
//		osal_mem_free(pxListitem);

//		return eMXS_ERR_NONE;
//	}else {
//		return eMXS_ERR_NTOBJ;
//	}
//}

///**
// * @fn      
// * @brief  
// * @param   
// * @return  */
//uint16 mixReadRamItem(char *pcKey , void *pcReadBuf , uint16 usReadSize)
//{
//	/* Get first node. */
//	ListItem_t* pxListitem;

//	/* Find the item. */
//	pxListitem = pxFindItem(pcKey);

//	if (pxListitem != NULL) {
//		return prvDataContentGet(pxListitem , pcReadBuf,usReadSize) ;
//	}else {
//		return 0;
//	}
//}

///**
// * @fn      
// * @brief   Create a object or modify
// * @param   
// * @return  */
//MixSaveStatusDef mixModifyRamItem(char *pcKey , void *pcBuf , uint32 usSize)
//{
//	/* Get first node. */
//	MixSaveStatusDef xMxsSta;
//	ListItem_t* pxListitem;

//	/* Find the item. */
//	pxListitem = pxFindItem(pcKey);

//	/* modify item. */
//	if (pxListitem != NULL) {
//		mixDeleteRamItem(pcKey);
//	}

//	xMxsSta = mixWriteRamItem(pcKey,pcBuf,usSize) ;
//	return xMxsSta;
//}

///*#############################################*/
///**
// * @fn      
// * @brief  write data to ram.
// * @param   
// * @return  */
//void vMxsWrite(char *pcKey , void *pcBuf , uint16 usSize)
//{
//	mixModifyRamItem(pcKey , pcBuf , usSize);

//}

///**
// * @fn      
// * @brief   
// * @param   
// * @return  */
//uint16 usMxsRead(char *pcKey , void *pcBuf , uint16 usReadSize)
//{
//	uint16 usGetVal;

//	/* Read form ram. */
//	usGetVal = mixReadRamItem(pcKey, pcBuf, usReadSize);
//	//LOG("\r\n");
//	//LOG("%s ram read size:%d\r\n",__FUNCTION__ , usGetVal);

//	if (usGetVal == 0 ){
//		
//		usGetVal = ef_get_env_blob(pcKey, pcBuf, usReadSize, NULL);
//		//LOG("\r\n");
//		//LOG("%s flash read size:%d\r\n", __FUNCTION__, usGetVal);

//		return usGetVal;
//	}

//	return usGetVal;
//}

///**
// * @fn      
// * @brief   write all item. to flash.
// * @param   
// * @return  */
//void vMxsStash(void)
//{
//	ListItem_t* xItem = NULL;
//	char* pcName;
//	uint8* pcBuf;
//	uint16 usSize;

//	while (1){
//		xItem = pxFirstItem();

//		if (xItem != NULL) {

//			/* Get first item name. */
//			pcName = prvNamePcGet(xItem);

//			/* first item data content. */
//			pcBuf = prvDataPcGet(xItem, &usSize);

//			/* print item data content. */
//			LOG("\r\n");
//			LOG("%s size:%d\r\n",__FUNCTION__ , usSize);
//			LOG_DUMP_BYTE(pcBuf , usSize);
//			LOG("\r\n");

//			/* to flash. */
//			ef_set_env_blob(pcName, pcBuf, usSize);

//			/* Update watch dog...... */

//			/* Delete item. */
//			mixDeleteRamItem(pcName);
//			
//		}else {
//			break;
//		}
//	}

//	LOG("\r\n");
//	LOG("%s use mem:%d\r\n", __FUNCTION__, ulTotalMem);
//}







